monai/apps/detection/networks/retinanet_detector.py (1)

519-522: ⚠️ Potential issue | 🟡 Minor

Missing space after period.

"is not defined.Please" → "is not defined. Please".

Proposed fix

             raise ValueError(
-                "`self.inferer` is not defined.Please refer to function self.set_sliding_window_inferer(*)."
+                "`self.inferer` is not defined. Please refer to function self.set_sliding_window_inferer(*)."
             )

,

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@monai/apps/detection/networks/retinanet_detector.py` around lines 519 - 522,
The ValueError message raised when self.inferer is None in retinanet_detector.py
contains a missing space after the period; update the string in the check inside
the method where self.inferer is validated (the block referencing self.inferer
and the suggestion to call self.set_sliding_window_inferer) to read
"`self.inferer` is not defined. Please refer to function
self.set_sliding_window_inferer(*)`" so there is a space after the period.

monai/transforms/spatial/functional.py (1)

57-76: Function implementation is sound; docstring lacks formal Args/Returns.

The logic correctly gates Blackwell GPUs (sm_120+). Consider adding explicit Args: and Returns: sections to align with Google-style docstrings per project conventions.

📝 Suggested docstring format

 def _compiled_unsupported(device: torch.device) -> bool:
     """
     Return True if ``monai._C`` (the compiled C extension providing ``grid_pull``) is not
     compiled with support for the given CUDA device's compute capability.
-
+    
+    Args:
+        device: The torch device to check for compiled extension support.
+    
+    Returns:
+        True if the device is CUDA with compute capability major >= 12 (Blackwell+),
+        False otherwise.
+    
     ``monai._C`` is built at install time against a fixed set of CUDA architectures.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@monai/transforms/spatial/functional.py` around lines 57 - 76, The
_compiled_unsupported function's docstring is missing formal Google-style
"Args:" and "Returns:" sections; update the docstring for
_compiled_unsupported(device: torch.device) to include an "Args:" entry
describing the device parameter (type and semantics) and a "Returns:" entry
stating it returns a bool indicating whether the compiled monai._C lacks support
for the device (True for CUDA devices with major compute capability >= 12, False
otherwise), keeping the existing explanatory text intact.

tests/transforms/test_spatial_gpu_support.py (3)

26-34: Redundant test: test_non_cuda_device_always_supported duplicates test_cpu_device_always_supported.

Both tests create a CPU device and assert the same condition. Either remove the duplicate or expand the second test to cover other non-CUDA device types (e.g., "mps" if relevant).

♻️ Suggested fix

-    def test_non_cuda_device_always_supported(self):
-        """Non-CUDA devices should always be supported."""
-        device = torch.device("cpu")
-        self.assertFalse(_compiled_unsupported(device))

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/transforms/test_spatial_gpu_support.py` around lines 26 - 34, The test
test_non_cuda_device_always_supported is a duplicate of
test_cpu_device_always_supported; remove the redundant test or replace it to
cover other non-CUDA device types (e.g., create torch.device("mps") and assert
False from _compiled_unsupported(device) when MPS is relevant), ensuring you
keep one explicit CPU check (test_cpu_device_always_supported) and either delete
test_non_cuda_device_always_supported or modify it to assert behavior for other
non-CUDA devices using the same helper _compiled_unsupported.

---

65-77: Consider overlap with TestCompiledUnsupported.test_cuda_device_detection.

This test duplicates CUDA detection logic from line 36-47. If both are intended, consolidate; otherwise pick one location.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/transforms/test_spatial_gpu_support.py` around lines 65 - 77, The test
test_compiled_unsupported_logic duplicates CUDA detection logic already present
in TestCompiledUnsupported.test_cuda_device_detection; remove the duplication by
either deleting test_compiled_unsupported_logic or merge its assertions into
TestCompiledUnsupported.test_cuda_device_detection, keeping the validation of
_compiled_unsupported(cuda_device) vs. cc_major >= 12 under a single test;
ensure the helper _compiled_unsupported is exercised exactly once for CUDA
detection to avoid redundant coverage.

---

36-47: Unnecessary conditionals inside skip-guarded test.

Line 39's ternary and line 40's if device.type == "cuda" are redundant—the @unittest.skipIf already guarantees CUDA availability. Simplify:

♻️ Suggested simplification

     `@unittest.skipIf`(not torch.cuda.is_available(), reason="CUDA not available")
     def test_cuda_device_detection(self):
         """Verify CUDA compute capability detection."""
-        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
-        if device.type == "cuda":
-            cc_major = torch.cuda.get_device_properties(device).major
-            unsupported = _compiled_unsupported(device)
-            # Device is unsupported if cc_major >= 12
-            if cc_major >= 12:
-                self.assertTrue(unsupported)
-            else:
-                self.assertFalse(unsupported)
+        device = torch.device("cuda:0")
+        cc_major = torch.cuda.get_device_properties(device).major
+        unsupported = _compiled_unsupported(device)
+        # Device is unsupported if cc_major >= 12
+        if cc_major >= 12:
+            self.assertTrue(unsupported)
+        else:
+            self.assertFalse(unsupported)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/transforms/test_spatial_gpu_support.py` around lines 36 - 47, The
test_cuda_device_detection contains redundant checks guarded by
`@unittest.skipIf`(torch.cuda.is_available()), so remove the ternary and inner if:
set device directly to torch.device("cuda:0") (no fallback), then call
torch.cuda.get_device_properties(device).major and _compiled_unsupported(device)
and assert based on cc_major >= 12; update references to device,
torch.cuda.is_available, and _compiled_unsupported accordingly to eliminate the
needless conditional branches.

tests/transforms/test_spacing.py (1)

34-37: Missing docstring on helper function.

Per coding guidelines, definitions should have docstrings describing parameters and return values.

📝 Suggested docstring

 def _template_5_expected_output(device: torch.device) -> torch.Tensor:
+    """Return expected output tensor for template 5 based on device capabilities.
+
+    Args:
+        device: Target torch device to check for compiled extension support.
+
+    Returns:
+        _TEMPLATE_5_COMPILED if compiled path is active, _TEMPLATE_5_NATIVE otherwise.
+    """
     if USE_COMPILED and not _compiled_unsupported(device):
         return _TEMPLATE_5_COMPILED
     return _TEMPLATE_5_NATIVE

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/transforms/test_spacing.py` around lines 34 - 37, Add a docstring to
the helper function _template_5_expected_output that briefly describes what the
function returns, documents the device parameter (type: torch.device) and the
return value (torch.Tensor), and notes behavior differences when USE_COMPILED is
true and _compiled_unsupported(device) is checked; place the docstring
immediately under the def line for _template_5_expected_output.